import axios from 'axios'
// import md5 from 'js-md5'

import Vue from 'vue'
import VueRouter from 'vue-router'
import router from '@/router'
import $store from '@/store'

import { ElNotification, ElMessage } from '@/assets/js/message.js'

Vue.use(VueRouter)
let Message = new ElMessage()
let Notify = new ElNotification()

//返回接口参数
let initModel = {
    code: 'Code',//调用接口返回状态
    value: true,//返回成功状态编码
    val: 200,//返回成功状态编码
    msg: 'Message'//返回错误信息
}
let initHeader = {
    Authorization: 'Authorization',
    pt_Key: 'pt_Key'
}

// 获取地址
let baseURL = ''
// 创建axios 请求
const httpRequset = axios.create({
    // 公共接口 (使用代理不启用这里的根地址)
    // baseURL: '/rsj-web',
    // 超时时间 单位是ms，这里设置了600s的超时时间
    timeout: 600 * 1000,
    async: true,
    crossDomain: true,
})
// 请求拦截器
httpRequset.interceptors.request.use(config => {
    //不是开发环境
    if (process.env.NODE_ENV != "development" && $store.getters.config.enable) {
        baseURL = $store.getters.config.baseURL
    }
    //不是请求本地文件则验证请求地址
    if (!config.location && baseURL) {
        if (config.url.indexOf('http') < 0) {
            config.url = baseURL + config.url
        }
    }
    delete config.location

    // //验证表头 是否需要传token
    if ($store.getters.token) {
        if (!config.token) {
            config.headers = {}
        }

        config.headers[initHeader.Authorization] = $store.getters.tokenHeader + $store.getters.token
        if (header[initHeader.pt_Key]) {
            config.headers[initHeader.pt_Key] = header[initHeader.pt_Key]
        }
    }

    console.log( config.headers)
    return config
}, error => {
    return Promise.reject(error)
})

// 响应拦截器
httpRequset.interceptors.response.use(response => {
    //     if (response.headers['x-session']) {
    //         store.dispatch('user/setSessionId', response.headers['x-session'])
    //     }

    let data = response.data
    // 需要验证提示消息
    if (!response.config.notcheck) {
        if (data) {
            if (data[initModel.code] != initModel.value && data[initModel.code] != initModel.val) {
                Notify.error(data[initModel.msg] || '未知错误')
            }
        }
    }
    if (response.config.callback) {
        response.config.callback(data)
    }
    if (header[initHeader.pt_Key]) {
        delete header[initHeader.pt_Key]
    }

    return Promise.resolve(data)
}, error => {
    let data
    if (error && error.response) {
        data = error.response.data
        if (typeof (data) !== 'object') {
            data = { code: -1, msg: '连接服务器失败', data: null, timestamp: new Date().getTime() }
        }
    } else {
        data = { code: -1, msg: '连接服务器失败', data: null, timestamp: new Date().getTime() }
    }
    Notify.error(data[initModel.msg] || '未知错误')
    if (error.response.status == 401) {
        router.push("/401")
    } else if (error.response.status == 404) {
        router.push("/4014")
    } else if (error.response.status == 412) {
        router.push("/login")
    }
    console.log('请求发生异常,原因：' + error.message)

    if (error.config.error) {
        error.config.error(data)
    }

    if (header[initHeader.pt_Key]) {
        delete header[initHeader.pt_Key]
    }
    return Promise.resolve(data)
})

// 请求header
let header = {
    'Content-Type': 'application/json;charset=utf-8',
    sn: new Date().getTime()
}

const http = {
    // 获取json文件或数据
    getJson(reqUrl, callback, error) {
        const config = {
            location: true,
            dataType: 'json',
            crossDomain: true,
            cache: false,
            method: 'get',
            url: reqUrl,
            notcheck: true, // 不需要验证
            callback: callback, // 执行回调
            error: error, //执行异步回调
        }
        return httpRequset(config)
    },
    // 获取json文件或数据
    ajax(reqUrl, reqMethod, reqData,  callback, error) {
        // if (anthCode && Object.prototype.toString.call(anthCode) != '[object String]') {
        //     Notify.error('未正常提供授权码')
        //     return
        // }
        // header.pt_Key = anthCode;
        if (Object.prototype.toString.call(callback) === '[object Function]') {
            callback(data)
        }
        // if (reqUrl.indexOf('http') < 0 && baseURL) {
        //     reqUrl = baseURL + reqUrl
        // }

        const config = {
            headers: header,
            dataType: 'json',
            crossDomain: true,
            cache: false,
            url: reqUrl,
            method: reqMethod,
            data: reqData,
            callback: callback, // 执行回调
            error: error, //执行异步回调
        }
        return httpRequset(config)
    },
    // 接收文件流
    getStream(reqUrl, fileName,  extension) {
        // if (anthCode && Object.prototype.toString.call(anthCode) != '[object String]') {
        //     Notify.error('未正常提供授权码')
        //     return
        // }
        let parm = {
            responseType: 'blob', // 指定返回数据的格式为blob    
            headers: {
                Authorization: $store.getters.tokenHeader + $store.getters.token,
                ContentType: "application/json;charset=UTF-8"
            }
        }
        // 拼接url
        if (fileName) {
            reqUrl += '?fileName=' + fileName
        }
        // this.get(reqUrl, {}, res => { })

        axios.get(reqUrl, parm).then(res => {
            // if(res[])
            // if (data[initModel.code] != initModel.value) {
            //     Notify.error(data[initModel.msg] || '未知错误')
            // }
            // 创建一个 a 标签，并隐藏 a 标签
            let a = document.createElement('a')
            a.style.display = 'none'

            // 对象 URL 绑定到 a 标签上
            a.href = window.URL.createObjectURL(new Blob([res.data]))

            // 给 a 标签添加 download 属性 与 文件名
            a.setAttribute('download', extension)

            // 把 a 标签挂载到 dom 树上并执行 a 标签的 click 事件
            document.body.appendChild(a)
            a.click()

            // 释放我们创建的 url 和 a 标签
            window.URL.revokeObjectURL(a.href)
            document.body.removeChild(a)
        }).catch(error => {
            Notify.error('下载文件失败，返回编码：' + error.response.status)
        })
    },
    // get请求数据 notcheck是否需要验证
    get(reqUrl, reqData,  callback, error) {
        // if (anthCode && Object.prototype.toString.call(anthCode) != '[object String]') {
        //     Notify.error('未正常提供授权码')
        //     return
        // }
        // header.pt_Key = anthCode;
        let index = reqUrl.indexOf('?');
        let parm = "";
        if (reqData) {
            Object.keys(reqData).forEach(attr => {
                if (!parm) {
                    if (index >= 0) {
                        parm += `&${attr}=${reqData[attr]}`
                    } else {
                        parm += `?${attr}=${reqData[attr]}`
                    }
                } else {
                    parm += `&${attr}=${reqData[attr]}`
                }
            })
        }
        reqUrl += parm

        const config = {
            //headers: header,
            dataType: 'json',
            crossDomain: true,
            cache: false,
            notcheck: false,
            method: 'get',
            url: reqUrl,
            callback: callback, // 执行回调
            error: error, //执行异步回调
        }

        return httpRequset(config)
    },
    // 通用接口请求
    generalAPI(reqData,  callback, error) {
        // if (anthCode && Object.prototype.toString.call(anthCode) != '[object String]') {
        //     Notify.error('未正常提供授权码')
        //     return
        // }
        // header.pt_Key = anthCode;
        const config = {
            headers: header,
            method: 'post',
            url: "/api/common/opera",
            crossDomain: true,
            notcheck: false,
            data: reqData,
            callback: callback, // 执行回调
            error: error, //执行异步回调
        }
        return httpRequset(config)
    },
    // POST请求数据
    post(reqUrl, reqData, callback, error) {
        // if (anthCode && Object.prototype.toString.call(anthCode) != '[object String]') {
        //     Notify.error('未正常提供授权码')
        //     return
        // }
        // header.pt_Key = anthCode;
        // headers: {
        //      'Content-Type': 'application/json',
        //      'x-session': store.getters['user/getSessionId'],
        //      'x-sign': md5(store.getters['app/getClientSecret'] + store.getters['app/getAppUid'] + timestamp),
        //      'x-client': store.getters['app/getClientType'],
        //      'x-timestamp': timestamp
        //  }
        const config = {
            headers: header,
            method: 'post',
            url: reqUrl,
            crossDomain: true,
            notcheck: false,
            data: reqData,
            callback: callback, // 执行回调
            error: error, //执行异步回调
        }
        return httpRequset(config)
    },
    // 请求操作数据
    operation(reqUrl, reqData, callback) {
        // if (anthCode && Object.prototype.toString.call(anthCode) != '[object String]') {
        //     Notify.error('未正常提供授权码')
        //     return
        // }
        // header.pt_Key = anthCode;
        const config = {
            headers: header,
            method: 'post',
            url: reqUrl,
            crossDomain: true,
            notcheck: false,
            data: reqData
        }

        // 接受回调函数
        httpRequset(config).then((data) => {
            if (data.code === 200) {
                // 验证是否未方法还是值
                if (Object.prototype.toString.call(callback) === '[object Function]') {
                    callback(data)
                } else {
                    Message.success('操作成功')
                    // 开始
                    let path = callback
                    if (path) {
                        // 跳转指定路由
                        router.push(path)
                    } else {
                        // 返回上级路由
                        let parentPath = router.currentRoute.meta.parentPath
                        if (parentPath) {
                            router.push(parentPath + '/true')
                        }
                    }
                    // end 结束
                }
            }
        })
    }
}


http.getJson('./jsonData/api.json', res => {
    if (res) {
        $store.dispatch('config/cache', res)
    }
})

// 导出http
export default http